/**
 * <p>文件名:		TObject.java</p>
 * <p>版权:		CopyrightTag</p>
 * <p>公司:		CompanyTag</p>
 * @author		周华彬(sheshidong@lingtu.com, letifly@21cn.com)
 */

package com.caits.lbs.framework.bean.common;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import com.caits.lbs.framework.Framework;
import com.caits.lbs.framework.utils.Base64Codec;
import com.caits.lbs.framework.utils.JsonUtil;
import com.caits.lbs.framework.utils.StringUtils;

/**
 * <p>
 * TObject
 * </p>
 * <p>
 * 树对象，使用级联的深度、宽度方式存储各种数据类型，满足对各种树状的参数的无边界、无深度支持
 * </p>
 * <p>
 * 如果存在子对象，那么子对象键不可以为空，如果值为t对象的话也不可以为空的t对象做值
 * </p>
 * <p>
 * 非线程安全的，如果需要统一使用线程安全的，可以通过开启TObject.ThreadSafe=true实现，不支持单个的
 * </p>
 * <p>
 * <strong>确认操作时不可以出现级联的put或者add，如果出现可能会在级联输出时发生无限迭代</strong>
 * </p>
 * <p>
 * 输出方式：<br>
 * <b>1、to*</b>：输出值，如果类型不对输出非正确值，toString是特殊输出，不推荐直接使用，所有的to类方法都是不可依赖的，使用一定要慎之又慎
 * ， 推荐不使用<br>
 * <b>2、as*</b>：输出值，如果类型不对那么抛出异常，不进行类型转换<br>
 * <b>3、cv*</b>：尝试转换输出值，如果类型不对则进行内部尝试，每种类型有固定的转换尝试逻辑，如果真的得不到，那么抛出异常<br>
 * <b>4、*Value</b>：得到某种类型值，如果此种值无法获取，那么给出此值的错误返回，会尝试进行内部转换，转换逻辑与cv必须保持一致<br>
 * </p>
 * <p>
 * 使用方式推荐：<br>
 * 1、如果作为协议交换推荐使用as方式，因为不会内部进行类型转换，并且可以抛出异常供外部处理捕获<br>
 * 2、如果最为日志输出，那么推荐使用to方式，因为其目的是表达一个可供人类读取的值<br>
 * 3、如果对于参数传递，那么推荐使用cv和value方式，这两种方式允许当参数以不同方式进入后获取时想用得值与输入值类型不同<br>
 * 4、如果需要捕获捕获，并且是参数读取、传递，那么只能使用cv，但是这个异常是ClassCastException，是非检查异常，要自行决定是否捕获<br>
 * </p>
 * 
 * @author 周华彬(sheshidong@lingtu.com, letifly@21cn.com)
 * @version 0.0.0
 *          <table style="border:1px solid gray;">
 *          <tr>
 *          <th width="100px">版本号</th><th width="100px">动作</th><th
 *          width="100px">修改人</th><th width="100px">修改时间</th>
 *          </tr>
 *          <!-- 以 Table 方式书写修改历史 -->
 *          <tr>
 *          <td>0.0.0</td>
 *          <td>创建类</td>
 *          <td>周华彬</td>
 *          <td>2008-10-17 下午09:58:01</td>
 *          </tr>
 *          <tr>
 *          <td>0.0.1</td>
 *          <td>添加系列方法，确定方法执行方向</td>
 *          <td>周华彬</td>
 *          <td>2008-11-24 上午10:58</td>
 *          </tr>
 *          <tr>
 *          <td>0.0.2</td>
 *          <td>添加、完善to*、as*、cv*、*value的方法</td>
 *          <td>周华彬</td>
 *          <td>2008-11-24 下午15:13</td>
 *          </tr>
 *          </table>
 */
public final class TreeObject implements Serializable, Cloneable {

	private static final long serialVersionUID = 1L;

	/** 是否线程安全，如果指定线程安全，那么其中构建复合对象时使用线程安全的集合（映射），否则使用线程不安全的集合（映射） */
	public static boolean ThreadSafe = false;

	/** T对象支持的版本集合，允许部分向上兼容 */
	public static final Set<String> SUPPORTED_VERSION_SET = new HashSet<String>();

	/** 当前版本 */
	public static final String VERSION = "0.0.2";

	/** null 类型，可输入值为null */
	public static final int NULL_TYPE = 00000;

	/** Integer 类型，取值范围为 -~ */
	public static final int INTEGER_TYPE = 00001;

	/** Long 类型，取值范围为 -~ */
	public static final int LONG_TYPE = 00010;

	/** Float 类型，取值范围为 */
	public static final int FLOAT_TYPE = 00011;

	/** Double 类型，取值范围为 */
	public static final int DOUBLE_TYPE = 00100;

	/** Boolean 类型，取值范围为 */
	public static final int BOOLEAN_TYPE = 00101;

	/** String 类型，取值范围为 */
	public static final int STRING_TYPE = 00110;

	/** Map&lt;String, ? extends Object&gt; 类型 */
	public static final int MAP_TYPE = 00111;

	/** Collection&lt;? extends Object&gt; 类型 */
	public static final int COLLECTION_TYPE = 01000;

	/** Byte 类型，取值范围为 */
	public static final int BYTE_TYPE = 01001;

	/** Character 类型，取值范围为 */
	public static final int CHAR_TYPE = 01010;

	/** Short 类型，取值范围为 */
	public static final int SHORT_TYPE = 01011;

	/** byte[] 类型 */
	public static final int BYTES_TYPE = 01100;

	/** Object 类型 */
	public static final int OBJECT_TYPE = 01101;

	/**
	 * 复合 String 类型，其中包括UTF-8的字符，或者存在包括换行等的复杂字符串<br>
	 * 因为在java内部并不进行区分，所以内部传输不推荐使用此，只在进行跨语言传输 ，或协议性传输的时候使用
	 */
	public static final int MIX_STRING_TYPE = 01110;

	/** 如果是数组型添加的话，那么使用这个作为索引的头，因为使用的是Map进行的实际存储 */
	private static final String ARRAY_INDEX_TAG = "__TOBJECT_ARRAY__";

	static {
		SUPPORTED_VERSION_SET.add("0.0.1");
		SUPPORTED_VERSION_SET.add("0.0.2");
	}

	/** 属性映射，如果是非单纯类型的话需要存放下属属性 */
	private Map<String, TreeObject> attMap;

	/** 数组对象的话使用这种方式管理索引 */
	private List<Integer> attIndexList;

	/** 当前数组的索引值，每个对象此值会累加，即使清空下面所有列 */
	private int currentIndex;

	/** 当前数据类型 */
	private int type;

	/** 当前数据对象 */
	private Object obj;

	/** 是简单值对象 */
	private boolean isValue;

	/** 是数组对象 */
	private boolean isArray;

	/** 是映射对象 */
	private boolean isMap;

	/**
	 * 构造单纯值t对象，其中数据对象为空，属性映射集合也为空
	 */
	public TreeObject() {
		isValue = true;
	}

	/**
	 * 构造单纯值字符串t对象
	 * 
	 * @param value
	 *            字符串对象
	 */
	public TreeObject(String value) {
		type = STRING_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造器复合串单纯值t对象
	 * 
	 * @param value
	 *            复合字符串，包括UTF-8字符或者存在回车换行等可能影响协议表达的复合字符串
	 * @param isMix
	 *            是否复合字符串，因为使用同样的String参数，所以没办法，只能这样，使用这个来区分，如果为false，那么复合值退化为简单字符串
	 */
	public TreeObject(String value, boolean isMix) {
		if (isMix) {
			type = MIX_STRING_TYPE;
		} else {
			type = STRING_TYPE;
		}
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值字节t对象
	 * 
	 * @param value
	 *            字节
	 */
	public TreeObject(byte value) {
		type = BYTE_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值短整型数字t对象
	 * 
	 * @param value
	 *            短整型数字
	 */
	public TreeObject(short value) {
		type = SHORT_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值整型数字t对象
	 * 
	 * @param value
	 *            整型数字
	 */
	public TreeObject(int value) {
		type = INTEGER_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值长整形数字t对象
	 * 
	 * @param value
	 *            长整形数字
	 */
	public TreeObject(long value) {
		type = LONG_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值单精度浮点数字t对象
	 * 
	 * @param value
	 *            单精度浮点数
	 */
	public TreeObject(float value) {
		type = FLOAT_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值双精度浮点数字t对象
	 * 
	 * @param value
	 *            双精度浮点数
	 */
	public TreeObject(double value) {
		type = DOUBLE_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值布尔t对象
	 * 
	 * @param value
	 *            布尔值
	 */
	public TreeObject(boolean value) {
		type = BOOLEAN_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造单纯值字节组t对象
	 * 
	 * @param value
	 *            字节数组
	 */
	public TreeObject(byte[] value) {
		type = BYTES_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造存放单纯值Map的T对象，不进行对象拆分<br>
	 * 如果想进行拆分，使用指定类型type的构造器
	 * 
	 * @see 构造进行对象拆分的Map的t对象 TObject(int type, Map<String, ? extends Object>
	 *      value)
	 * 
	 * @param map
	 *            单纯值Map对象，键必须为String，值为Object
	 */
	public TreeObject(Map<String, ? extends Object> value) {
		type = MAP_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造需要进行按照类型拆分的Map的t对象，构造后是 isMap == true 的t对象
	 * 
	 * @param type
	 *            需要识别Map中object的类型码
	 * @param value
	 *            需要拆分的Map对象
	 */
	public TreeObject(int type, Map<String, ? extends Object> value) {
		if (value != null && !value.isEmpty()) {
			isMap = true;
			for (String key : value.keySet()) {
				put(key, new TreeObject(type, value.get(key)));
			}
			this.type = type;
		}
	}

	/**
	 * 构造存放集合单纯值的T对象，不进行对象拆分，如果想进行拆分，使用指定类型的构造器
	 * 
	 * @see 构造器 TObject(int type, Collection<? extends Object> value)
	 * @param value
	 *            单纯值集合对象
	 */
	public TreeObject(Collection<? extends Object> value) {
		type = COLLECTION_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 构造需要按照type指定类型的集合型t对象，需要将Collection拆分存放与t对象中
	 * 
	 * @param type
	 *            需要识别集合数据类型的类型码
	 * @param value
	 *            需要拆分的集合对象，只有不为空才会认为结果是集合t对象
	 */
	public TreeObject(int type, Collection<? extends Object> value) {
		if (value != null && !value.isEmpty()) {
			for (Object o : value) {
				add(new TreeObject(type, o));
			}
			isArray = true;
			isMap = false;
			this.type = type;
		}
	}

	/**
	 * 构造非指定类型的单纯值t对象
	 * 
	 * @param value
	 *            标准对象值对象
	 */
	public TreeObject(Object value) {
		type = OBJECT_TYPE;
		obj = value;
		isValue = true;
	}

	/**
	 * 根据给定对象进行属性拆解，通过调用其中的bean方法（get*）进行内部值的探测，并组装成一个t对象<br>
	 * 根据输入对象的内容级别来决定是单纯值isValue还是映射复合值isMap或者是数组复合值isArray
	 * 
	 * @param value
	 *            需要进行拆解的对象，如果是原生类型（int等的包装了）使用单纯值，如果是实体类型，那么是映射Map，如果实现了Collection
	 *            ，那么是集合值Collection
	 * @param includeSuperClass
	 *            是否包括需要拆解父类
	 */
	public TreeObject(Object value, boolean includeSuperClass) {
		throw new NullPointerException("当前构造方法未成功实现");
	}

	/**
	 * 根据指定类型和输入的串进行构造t对象，只有在允许确定的将string转换为t对象，对于每种期望输出的type类型有固定的
	 * 
	 * @param type
	 *            需要转换为实际存储的类型码
	 * @param value
	 *            用来构造t对象的串
	 * @deprecated 执行效率较低，用作将其他以字符串方式进行传输的数据输入进入t对象，此类方法会在将来使用统一的convert类进行转换
	 */
	public TreeObject(int type, String value) {
		this.type = type;
		isValue = true;
		if (value == null) {
			obj = null;
			return;
		}
		switch (type) {
		case INTEGER_TYPE:
			try {
				obj = Integer.parseInt(value);
			} catch (NumberFormatException e) {
				obj = Integer.MIN_VALUE;
			}
			break;
		case LONG_TYPE:
			try {
				obj = Long.parseLong(value);
			} catch (NumberFormatException e) {
				obj = Long.MIN_VALUE;
			}
			break;
		case FLOAT_TYPE:
			try {
				obj = Float.parseFloat(value);
			} catch (NumberFormatException e) {
				obj = Float.MIN_VALUE;
			}
			break;
		case DOUBLE_TYPE:
			try {
				obj = Double.parseDouble(value);
			} catch (NumberFormatException e) {
				obj = Double.MIN_VALUE;
			}
			break;
		case BOOLEAN_TYPE:
			obj = Boolean.parseBoolean(value);
			break;
		case STRING_TYPE:
			obj = value;
			break;
		case MAP_TYPE:
		case COLLECTION_TYPE:
			throw new ClassCastException(VERSION
					+ " 版本不支持解析Map或者Collection字符串转换称对应的对象");
		case BYTE_TYPE:
			try {
				obj = Base64Codec.decode(value.toCharArray())[0];
			} catch (ArrayIndexOutOfBoundsException e) {
				obj = Byte.MIN_VALUE;
			}
			break;
		case CHAR_TYPE:
			try {
				obj = value.toCharArray()[0];
			} catch (ArrayIndexOutOfBoundsException e) {
				obj = Character.MIN_VALUE;
			}
			break;
		case SHORT_TYPE:
			try {
				obj = Short.parseShort(value);
			} catch (NumberFormatException e) {
				obj = Short.MIN_VALUE;
			}
			break;
		case BYTES_TYPE:
			obj = Base64Codec.decode(value.toCharArray());
			break;
		case OBJECT_TYPE:
			throw new ClassCastException();
		case MIX_STRING_TYPE:
			obj = Base64Codec.decode(value);
			break;
		default:
			throw new ClassCastException(type + " 数据类型未知，无法从串 " + value
					+ " 转换出存储类型");
		}

	}

	/**
	 * 构造指定类型的单纯值对象
	 * 
	 * @param type
	 *            数据类型编码，对于泛型编程时很有用，但是现在几乎不使用
	 * @param value
	 *            存储值对象
	 */
	public TreeObject(int type, Object value) {
		this.type = type;
		obj = value;
		isValue = true;
	}

	/**
	 * 是否包含指定子节点
	 * 
	 * @param key
	 *            需要检查的子节点名称标识
	 * @return 只有当前t对象为map
	 */
	public boolean has(String key) {
		if (!isMap || StringUtils.isNullOrBlank(key) || attMap == null
				|| attMap.isEmpty()) {
			return false;
		} else {
			return attMap.containsKey(key);
		}
	}

	/**
	 * 当前t对象的宽度，也即第一级的size<br>
	 * 如果是单纯值isValue并且值不为空那么为1，如果为空则是0<br>
	 * 如果是映射值isMap并且值不为空的话为对应map的size，如果为空则是0<br>
	 * 如果是集合值isArray并且值不为空的话为对应collection的size，如果为空则是0<br>
	 * 
	 * @return 0-n，根据不同类型宽度值是不同的
	 */
	public int width() {
		throw new NullPointerException(VERSION + " 不支持宽度 width 获取");
	}

	/**
	 * 当前t对象的深度，需要广度搜索，使用级联的获取深度，直到最深的一级为单纯值时停止
	 * 
	 * @return 1-n，如果当前为单纯值那么肯定为1，不论当前其中的值是否为空
	 */
	public int depth() {
		throw new NullPointerException(VERSION + " 不支持深度 depth 获取");
	}

	/**
	 * 添加一个子T对象，并返回这个添加的子对象，如果子对象为空，那么抛出异常
	 * 
	 * @param key
	 *            子T对象名称，不可为空
	 * @param value
	 *            子T对象，不可为空
	 * @return 当前成功添加的子T对象，决不为空<br>
	 *         可以用来实现级联的调用，如<br>
	 *         t.put("key-level-1", new TObject()).put("key-level-2", new
	 *         TObject())...;
	 */
	public TreeObject put(String key, TreeObject value) {
		if (StringUtils.isNullOrBlank(key) || value == null) {
			throw new NullPointerException("给定键 " + key + " 或值为空，无法添加子t对象");
		}
		isMap = true;
		isArray = false;
		isValue = false;
		if (attMap == null) {
			if (ThreadSafe) {
				attMap = new ConcurrentHashMap<String, TreeObject>();
			} else {
				attMap = new HashMap<String, TreeObject>();
			}
		}
		attMap.put(key, value);
		return value;
	}

	/**
	 * 添加一个子T对象，其中为单纯值的串类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的字符串值，如果为空依然会建立子对象，但是子对象中的值为空
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, String value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中可能为复合型的串类型或者简单的串类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的字符串值，如果为空依然会建立子对象，但是子对象中的值为空
	 * @param isMix
	 *            是否复合字符串，因为使用同样的String参数，所以没办法，只能这样，使用这个来区分，如果为false，那么复合值退化为简单字符串
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, String value, boolean isMix) {
		return put(key, new TreeObject(value, isMix));
	}

	/**
	 * 添加一个子T对象，其中为字节类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的字节
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, byte value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为短整型数字类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的短整型数字
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, short value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为整型数字类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的整型数字
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, int value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为长整型数字类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的长整型数字
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, long value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为单精度浮点数字类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的单精度浮点数字
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, float value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为双精度浮点数字类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的双精度浮点数字
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, double value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为布尔类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的布尔值
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, boolean value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为byte数组
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的byte数组，如果为空依然会建立子对象，但是子对象中的值为空
	 * 
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, byte[] value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为Map映射对象
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的映射对象，如果为空依然会建立子对象，但是子对象中的值为空
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, Map<String, ? extends Object> value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 将一个映射对象按照指定type数据类型进行拆解，并保存在当前的t对象上，如果某些已经存在那么覆盖已经添加过的键对应的子t对象
	 * 
	 * @param type
	 *            需要批量添加进的类型码
	 * @param value
	 *            需要添加的映射，如果为空则不进行添加，如果不为空则映射中每个key不可为空
	 * @return 成功添加的子t对象映射，不论如何决不为空，即使当前value给定值为空
	 */
	public Map<String, TreeObject> putAll(int type,
			Map<String, ? extends Object> value) {
		Map<String, TreeObject> map = new HashMap<String, TreeObject>();
		if (value == null) {
			return map;
		}
		for (String k : value.keySet()) {
			if (StringUtils.isNullOrBlank(k)) {
				continue;
			}
			Object o = value.get(k);
			if (o == null) {
				continue;
			}
			TreeObject to = put(k, type, o);
			if (to == null) {
				continue;
			}
			map.put(k, to);
		}

		return map;
	}

	/**
	 * 添加一个子t对象，其中值为集合对象
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的集合对象，如果为空则添加的子对象的存储对象为空
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, Collection<? extends Object> value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，其中为对象
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param value
	 *            需要添加的对象，如果为空依然会建立子对象，但是子对象中的值为空
	 * 
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, Object value) {
		return put(key, new TreeObject(value));
	}

	/**
	 * 添加一个子T对象，添加指定类型的对象，但是从串产生，用在协议转换时
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param type
	 *            子对象添加的类型
	 * @param value
	 *            用来构建子对象的串
	 * @return 当前成功添加的子T对象，决不为空
	 * @deprecated 因使用TObject(int, String)构造方法添加，所以效率很低，慎用
	 */
	public TreeObject put(String key, int type, String value) {
		return put(key, new TreeObject(type, value));
	}

	/**
	 * 添加一个子t对象，指定添加类型
	 * 
	 * @param key
	 *            需要添加的子T对象键值，不可为空
	 * @param type
	 *            子对象添加的类型
	 * @param value
	 *            添加的子对象存储对象，如果为空则创建的子对象的存储值为空
	 * @return 当前成功添加的子T对象，决不为空
	 */
	public TreeObject put(String key, int type, Object value) {
		return put(key, new TreeObject(type, value));
	}

	/**
	 * 获取子t对象，只有当当前t对象为map的时候才会进行获取
	 * 
	 * @param key
	 *            需要获取子对象键名
	 * @return 如果存在对应键的子t对象，那么返回这个子t对象
	 */
	public TreeObject get(String key) {
		if (!isMap || StringUtils.isNullOrBlank(key) || attMap == null
				|| attMap.isEmpty()) {
			return null;
		} else {
			return attMap.get(key);
		}
	}

	/**
	 * 获取子t对象的串值，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.STRING_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.STRING_TYPE，那么抛出异常
	 */
	public String getString(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return null;
		} else {
			return to.asString();
		}
	}

	/**
	 * 获取子t对象的复合串值，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.MIX_STRING_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.MIX_STRING_TYPE，那么抛出异常
	 */
	public String getMix(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return null;
		} else {
			return to.asMixString();
		}
	}

	/**
	 * 获取子t对象的字节值，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.BYTE_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.BYTE_TYPE，那么抛出异常
	 */
	public byte getByte(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return Byte.MIN_VALUE;
		} else {
			return to.asByte();
		}
	}

	/**
	 * 获取子t对象的短整型数字，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.SHORT_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.SHORT_TYPE，那么抛出异常
	 */
	public short getShort(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return Short.MIN_VALUE;
		} else {
			return to.asShort();
		}
	}

	/**
	 * 获取子t对象的整型数字，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.INTEGER_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.INTEGER_TYPE，那么抛出异常
	 */
	public int getInt(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return Integer.MIN_VALUE;
		} else {
			return to.asInt();
		}
	}

	/**
	 * 获取子t对象的长整型数字，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.LONG_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.LONG_TYPE，那么抛出异常
	 */
	public long getLong(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return Long.MIN_VALUE;
		} else {
			return to.asLong();
		}
	}

	/**
	 * 获取子t对象的单精度浮点数字，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.FLOAT_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.FLOAT_TYPE，那么抛出异常
	 */
	public float getFloat(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return Float.MIN_VALUE;
		} else {
			return to.asFloat();
		}
	}

	/**
	 * 获取子t对象的双精度浮点数字，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.DOUBLE_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.DOUBLE_TYPE，那么抛出异常
	 */
	public double getDouble(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return Double.MIN_VALUE;
		} else {
			return to.asDouble();
		}
	}

	/**
	 * 获取子t对象的布尔值，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.BOOLEAN_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.BOOLEAN_TYPE，那么抛出异常
	 */
	public boolean getBoolean(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return false;
		} else {
			return to.asBoolean();
		}
	}

	/**
	 * 获取子t对象的字节组，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.BYTES_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.BYTES_TYPE，那么抛出异常
	 */
	public byte[] getBytes(String key) throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return null;
		} else {
			return to.asBytes();
		}
	}

	/**
	 * 获取子t对象的映射对象，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.MAP_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.MAP_TYPE，那么抛出异常
	 */
	public Map<String, ? extends Object> getMap(String key)
			throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return null;
		} else {
			return to.asMap();
		}
	}

	/**
	 * 获取子t对象的集合对象，使用as进行获取子对象内容输出
	 * 
	 * @param key
	 *            需要获取的子对象键名
	 * @return 如果当前获取的键存在并且数据类型为 TObject.COLLECTION_TYPE
	 * @throws ClassCastException
	 *             如果对应键的子t对象类型非 TObject.COLLECTION_TYPE，那么抛出异常
	 */
	public Collection<? extends Object> getCollection(String key)
			throws ClassCastException {
		TreeObject to = get(key);
		if (to == null) {
			return null;
		} else {
			return to.asArray();
		}
	}

	/**
	 * 添加一个子t对象，如果当前为map则使用内设键值添加对象
	 * 
	 * @param o
	 *            需要添加的t对象，如果给定值为空则不进行添加
	 */
	public void add(TreeObject o) {
		if (o == null) {
			return;
		}

		if (attIndexList == null) {
			attIndexList = new LinkedList<Integer>();
		}
		attIndexList.add(++currentIndex);
		if (attMap == null) {
			attMap = new HashMap<String, TreeObject>();
		}
		attMap.put(ARRAY_INDEX_TAG + currentIndex, o);
		if (!isMap) {
			isArray = true;
		}
		isValue = false;
	}

	/**
	 * 添加一个子t对象，添加值为单纯值串，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的串，如果为空则添加成功的子t对象中值为空
	 */
	public void add(String value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为单纯值复合串，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的复合串，如果为空则添加成功的子t对象中值为空
	 * @param isMix
	 *            是否使用复合串，如果为true则标示添加复合串，否则为简单串
	 */
	public void add(String value, boolean isMix) {
		add(new TreeObject(value, isMix));
	}

	/**
	 * 添加一个子t对象，添加值为字节，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的字节
	 */
	public void add(byte value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为短整型数字，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的短整型数字
	 */
	public void add(short value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为整型数字，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的整型数字
	 */
	public void add(int value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为长短整型数字，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的长短整型数字
	 */
	public void add(long value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为单精度浮点数字，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的单精度浮点数字
	 */
	public void add(float value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为双精度浮点数字，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的双精度浮点数字
	 */
	public void add(double value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为布尔值，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的布尔值
	 */
	public void add(boolean value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为字节数组，如果当前为map则使用内设键值添加对象
	 * 
	 * @param value
	 *            需要添加的字节数组
	 */
	public void add(byte[] value) {
		add(new TreeObject(value));
	}

	/**
	 * 添加一个子t对象，添加值为映射map对象
	 * 
	 * @param value
	 *            需要添加的映射map对象
	 */
	public void add(Map<String, ? extends Object> value) {
		if (value == null) {
			throw new NullPointerException("");
		}
		add(new TreeObject(value));
	}

	/**
	 * 批量将映射的值添加为子t对象
	 * 
	 * @param type
	 *            确定的值对象类型
	 * @param value
	 *            添加的映射对象，如果为空则不进行添加
	 */
	public void addAllValue(int type, Map<String, ? extends Object> value) {
		if (value == null) {
			return;
		}
		for (Object o : value.values()) {
			if (o == null) {
				continue;
			}
			add(new TreeObject(type, o));
		}
	}

	/**
	 * 添加一个子t对象，添加值为集合Collection对象
	 * 
	 * @param value
	 *            需要添加的集合Collection对象
	 */
	public void add(Collection<? extends Object> value) {
		add(new TreeObject(value));
	}

	/**
	 * 批量将集合中的对象添加为子t对象
	 * 
	 * @param type
	 *            需要添加的类型码
	 * @param value
	 *            添加的集合对象，如果为空则不进行添加
	 */
	public void addAll(int type, Collection<? extends Object> value) {
		if (value == null) {
			return;
		}
		for (Object o : value) {
			if (o == null) {
				continue;
			}
			add(new TreeObject(type, o));
		}
	}

	/**
	 * 从串转换为指定类型后添加为子t对象
	 * 
	 * @param type
	 *            将串转换的类型码
	 * @param value
	 *            用来转换为t对象的源串
	 */
	public void add(int type, String value) {
		add(new TreeObject(type, value));
	}

	/**
	 * 添加指定类型的子t对象
	 * 
	 * @param type
	 *            需要添加子对象的类型码
	 * @param value
	 *            需要添加的对象
	 */
	public void add(int type, Object value) {
		add(new TreeObject(type, value));
	}

	/**
	 * 输出可人类识别的数字，如果当前内部存储为空或者类型不对那么返回无效值，否则返回对应值
	 * 
	 * @return 数字串，如果 <= Integer.MIN_VALUE 那么为无效值
	 */
	public int toInt() {
		if (isValue && obj != null && type == INTEGER_TYPE) {
			return (Integer) obj;
		}
		return Integer.MIN_VALUE;
	}

	/**
	 * 获取整型值，只有当为单纯值并且内部存储不为空，而且类型为整型的时候输出值，否则抛出类型转换异常
	 * 
	 * @return 如果当前值
	 * @throws ClassCastException
	 */
	public int asInt() throws ClassCastException {
		if (isValue && type == INTEGER_TYPE) {
			if (obj != null) {
				return (Integer) obj;
			} else {
				return Integer.MIN_VALUE;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 INTEGER_TYPE 类型");
	}

	/**
	 * 尝试转换当前值为int整数值
	 * 
	 * @return 转换出来的整数值，满足int的数字范围要求，特别的<=
	 *         Integer.MIN_VALUE或者>=Integer.MAX_VALUE为无效值
	 * @throws ClassCastException
	 *             尝试转换当前内容为整数异常
	 */
	public int cvInt() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return Integer.MIN_VALUE;
			}
			switch (type) {
			case INTEGER_TYPE:
				return (Integer) obj;
			case LONG_TYPE:
				return ((Long) obj).intValue();
			case FLOAT_TYPE:
				return ((Float) obj).intValue();
			case DOUBLE_TYPE:
				return ((Double) obj).intValue();
			case BYTE_TYPE:
				return ((Byte) obj).intValue();
			case CHAR_TYPE:
				return Character.digit((Character) obj, 10);
			case SHORT_TYPE:
				return ((Short) obj).intValue();
			case STRING_TYPE:
				try {
					return Integer.parseInt((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 STRING_TYPE 转换为 INTEGER_TYPE 输出");
				}
			case MIX_STRING_TYPE:
				try {
					return Integer.parseInt((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 MIX_STRING_TYPE 转换为 INTEGER_TYPE 输出");
				}
			default:
				throw new ClassCastException("不可转换为 INTEGER_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * 尝试获取当前值为int整数值
	 * 
	 * @return 转换出来的整数值，满足int的数字范围要求，特别的<=
	 *         Integer.MIN_VALUE或者>=Integer.MAX_VALUE为无效值
	 */
	public int intValue() {
		if (isValue) {
			if (obj != null) {
				switch (type) {
				case INTEGER_TYPE:
					return (Integer) obj;
				case LONG_TYPE:
					return ((Long) obj).intValue();
				case FLOAT_TYPE:
					return ((Float) obj).intValue();
				case DOUBLE_TYPE:
					return ((Double) obj).intValue();
				case BYTE_TYPE:
					return ((Byte) obj).intValue();
				case CHAR_TYPE:
					return Character.digit((Character) obj, 10);
				case SHORT_TYPE:
					return ((Short) obj).intValue();
				case STRING_TYPE:
					try {
						return Integer.parseInt((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				case MIX_STRING_TYPE:
					try {
						return Integer.parseInt((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				default:
				}
			}
		}
		return Integer.MIN_VALUE;

	}

	/**
	 * 输出可人类识别的数字，如果当前内部存储为空或者类型不对那么返回无效值，否则返回对应值
	 * 
	 * @return 数字串，如果 <= Long.MIN_VALUE 那么为无效值
	 */
	public long toLong() {
		if (isValue && obj != null && type == LONG_TYPE) {
			return (Long) obj;
		} else {
			return Long.MIN_VALUE;
		}
	}

	/**
	 * 获取长整型值，只有当为单纯值并且内部存储不为空，而且类型为长整型的时候输出值，否则抛出类型转换异常
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public long asLong() throws ClassCastException {
		if (isValue && type == LONG_TYPE) {
			if (obj != null) {
				return (Long) obj;
			} else {
				return Long.MIN_VALUE;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 LONG_TYPE 类型");
	}

	/**
	 * 尝试转换当前值为long长整数值
	 * 
	 * @return 转换出来的长整数值，满足long的数字范围要求，特别的<=
	 *         Long.MIN_VALUE或者>=Long.MAX_VALUE为无效值
	 * @throws ClassCastException
	 *             尝试转换当前内容为长整数异常
	 */
	public long cvLong() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return Long.MIN_VALUE;
			}
			switch (type) {
			case INTEGER_TYPE:
				return (Integer) obj;
			case LONG_TYPE:
				return ((Long) obj).longValue();
			case FLOAT_TYPE:
				return ((Float) obj).longValue();
			case DOUBLE_TYPE:
				return ((Double) obj).longValue();
			case BYTE_TYPE:
				return ((Byte) obj).longValue();
			case CHAR_TYPE:
				return Character.digit((Character) obj, 10);
			case SHORT_TYPE:
				return ((Short) obj).longValue();
			case STRING_TYPE:
				try {
					return Long.parseLong((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 STRING_TYPE 转换为 LONG_TYPE 输出");
				}
			case MIX_STRING_TYPE:
				try {
					return Long.parseLong((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 MIX_STRING_TYPE 转换为 LONG_TYPE 输出");
				}
			default:
				throw new ClassCastException("不可转换为 LONG_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * 尝试获取当前值为long长整数值
	 * 
	 * @return 转换出来的长整数值，满足long的数字范围要求，特别的<=
	 *         Long.MIN_VALUE或者>=Long.MAX_VALUE为无效值
	 */
	public long longValue() {
		if (isValue) {
			if (obj != null) {
				switch (type) {
				case INTEGER_TYPE:
					return (Integer) obj;
				case LONG_TYPE:
					return ((Long) obj).longValue();
				case FLOAT_TYPE:
					return ((Float) obj).longValue();
				case DOUBLE_TYPE:
					return ((Double) obj).longValue();
				case BYTE_TYPE:
					return ((Byte) obj).longValue();
				case CHAR_TYPE:
					return Character.digit((Character) obj, 10);
				case SHORT_TYPE:
					return ((Short) obj).longValue();
				case STRING_TYPE:
					try {
						return Long.parseLong((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				case MIX_STRING_TYPE:
					try {
						return Long.parseLong((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				}
			}
		}
		return Long.MIN_VALUE;

	}

	/**
	 * 输出字符串描述，不可用于将其他类型转换为字符串时使用，仅可用作调试等非限制性输出的语境<br>
	 * 如果发现确实需要输出为字符串，并且逻辑也符合，例如输出到协议的文本中，那么推荐使用cvString，其中包含强制类型转换
	 * 
	 * @return 尝试将内部属性转换为文字输出，不能保证其格式的规范性和输出的确定性，如果发现使用请求修改
	 */
	public String toString() {
		if (Framework.Debug) {
			return  JsonUtil.getJsonStringFromObject( this).toString();
		} else {
			return super.toString();
		}
	}

	/**
	 * 输出为单纯值字符串
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public String asString() throws ClassCastException {
		if (isValue && type == STRING_TYPE) {
			if (obj != null) {
				return obj.toString();
			} else {
				return null;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 STRING_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public String cvString() throws ClassCastException {
		if (obj == null) {
			return "";
		}
		if (isValue) {
			switch (type) {
			case INTEGER_TYPE:
				return Integer.toString((Integer) obj);
			case LONG_TYPE:
				return Long.toString((Long) obj);
			case FLOAT_TYPE:
				return Float.toString((Float) obj);
			case DOUBLE_TYPE:
				return Double.toString((Double) obj);
			case BOOLEAN_TYPE:
				return Boolean.toString((Boolean) obj);
			case STRING_TYPE:
				return obj.toString();
			case MAP_TYPE:
			case COLLECTION_TYPE:
				return obj.toString();
			case BYTE_TYPE:
				return new String(Base64Codec.encode(new byte[] { (Byte) obj }));
			case CHAR_TYPE:
				return String.valueOf(obj);
			case SHORT_TYPE:
				return Short.toString((Short) obj);
			case BYTES_TYPE:
				return new String(Base64Codec.encode((byte[]) obj));
			case OBJECT_TYPE:
				return obj.toString();
			case MIX_STRING_TYPE:
				return Base64Codec.encode(obj.toString());
			default:
				return obj.toString();
			}
		}
		return super.toString();
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public String stringValue() {
		if (obj == null) {
			return "";
		}
		if (isValue) {
			switch (type) {
			case INTEGER_TYPE:
				return Integer.toString((Integer) obj);
			case LONG_TYPE:
				return Long.toString((Long) obj);
			case FLOAT_TYPE:
				return Float.toString((Float) obj);
			case DOUBLE_TYPE:
				return Double.toString((Double) obj);
			case BOOLEAN_TYPE:
				return Boolean.toString((Boolean) obj);
			case STRING_TYPE:
				return obj.toString();
			case MAP_TYPE:
			case COLLECTION_TYPE:
				return obj.toString();
			case BYTE_TYPE:
				return new String(Base64Codec.encode(new byte[] { (Byte) obj }));
			case CHAR_TYPE:
				return String.valueOf(obj);
			case SHORT_TYPE:
				return Short.toString((Short) obj);
			case BYTES_TYPE:
				return new String(Base64Codec.encode((byte[]) obj));
			case OBJECT_TYPE:
				return obj.toString();
			case MIX_STRING_TYPE:
				return Base64Codec.encode(obj.toString());
			default:
				return obj.toString();
			}
		}
		return super.toString();
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public String toMixString() {
		if (isValue && obj != null && type == MIX_STRING_TYPE) {
			return obj.toString();
		} else {
			return "";
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public String asMixString() throws ClassCastException {
		if (isValue && type == MIX_STRING_TYPE) {
			if (obj != null) {
				return obj.toString();
			} else {
				return null;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 MIX_STRING_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public String cvMixString() throws ClassCastException {
		return Base64Codec.encode(cvString());
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public String mixStringValue() {
		return Base64Codec.encode(stringValue());
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public char toChar() {
		if (isValue && obj != null && type == CHAR_TYPE) {
			return (Character) obj;
		} else {
			return Character.MIN_VALUE;
		}
	}

	/**
	 * 输出为单纯值字符
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public char asChar() throws ClassCastException {
		if (isValue && type == CHAR_TYPE) {
			if (obj != null) {
				return (Character) obj;
			} else {
				return Character.MIN_VALUE;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 CHAR_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public char cvChar() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return Character.MIN_VALUE;
			}
			if (type == CHAR_TYPE) {
				return (Character) obj;
			} else {
				throw new ClassCastException("不可转换为 CHAR_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public char charValue() {
		if (isValue && obj != null && type == CHAR_TYPE) {
			return (Character) obj;
		} else {
			return Character.MIN_VALUE;
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public short toShort() {
		if (isValue && obj != null && type == SHORT_TYPE) {
			return (Short) obj;
		} else {
			return Short.MIN_VALUE;
		}
	}

	/**
	 * 输出为单纯值短整型
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public short asShort() throws ClassCastException {
		if (isValue && type == SHORT_TYPE) {
			if (obj != null) {
				return (Short) obj;
			} else {
				return Short.MIN_VALUE;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 SHORT_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public short cvShort() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return Short.MIN_VALUE;
			}
			switch (type) {
			case INTEGER_TYPE:
				return ((Integer) obj).shortValue();
			case LONG_TYPE:
				return ((Long) obj).shortValue();
			case FLOAT_TYPE:
				return ((Float) obj).shortValue();
			case DOUBLE_TYPE:
				return ((Double) obj).shortValue();
			case BYTE_TYPE:
				return ((Byte) obj).shortValue();
			case CHAR_TYPE:
				return (short) Character.digit((Character) obj, 10);
			case SHORT_TYPE:
				return (Short) obj;
			case STRING_TYPE:
				try {
					return Short.parseShort((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 STRING_TYPE 转换为 SHORT_TYPE 输出");
				}
			case MIX_STRING_TYPE:
				try {
					return Short.parseShort((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 MIX_STRING_TYPE 转换为 SHORT_TYPE 输出");
				}
			default:
				throw new ClassCastException("不可转换为 SHORT_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public short shortValue() {
		if (isValue) {
			if (obj != null) {
				switch (type) {
				case INTEGER_TYPE:
					return ((Integer) obj).shortValue();
				case LONG_TYPE:
					return ((Long) obj).shortValue();
				case FLOAT_TYPE:
					return ((Float) obj).shortValue();
				case DOUBLE_TYPE:
					return ((Double) obj).shortValue();
				case BYTE_TYPE:
					return ((Byte) obj).shortValue();
				case CHAR_TYPE:
					return (short) Character.digit((Character) obj, 10);
				case SHORT_TYPE:
					return (Short) obj;
				case STRING_TYPE:
					try {
						return Short.parseShort((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				case MIX_STRING_TYPE:
					try {
						return Short.parseShort((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				}
			}
		}
		return Short.MIN_VALUE;

	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public float toFloat() {
		if (isValue && obj != null && type == FLOAT_TYPE) {
			return (Float) obj;
		} else {
			return Float.MIN_VALUE;
		}
	}

	/**
	 * 输出为单纯值浮点数
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public float asFloat() throws ClassCastException {
		if (isValue && type == FLOAT_TYPE) {
			if (obj != null) {
				return (Float) obj;
			} else {
				return Float.MIN_VALUE;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 FLOAT_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public float cvFloat() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return Float.MIN_VALUE;
			}
			switch (type) {
			case INTEGER_TYPE:
				return ((Integer) obj).floatValue();
			case LONG_TYPE:
				return ((Long) obj).floatValue();
			case FLOAT_TYPE:
				return (Float) obj;
			case DOUBLE_TYPE:
				return ((Double) obj).floatValue();
			case BYTE_TYPE:
				return ((Byte) obj).floatValue();
			case CHAR_TYPE:
				return (float) Character.digit((Character) obj, 10);
			case SHORT_TYPE:
				return ((Short) obj).floatValue();
			case STRING_TYPE:
				try {
					return Float.parseFloat((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 STRING_TYPE 转换为 FLOAT_TYPE 输出");
				}
			case MIX_STRING_TYPE:
				try {
					return Float.parseFloat((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 MIX_STRING_TYPE 转换为 FLOAT_TYPE 输出");
				}
			default:
				throw new ClassCastException("不可转换为 FLOAT_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public float floatValue() {
		if (isValue) {
			if (obj != null) {
				switch (type) {
				case INTEGER_TYPE:
					return ((Integer) obj).floatValue();
				case LONG_TYPE:
					return ((Long) obj).floatValue();
				case FLOAT_TYPE:
					return (Float) obj;
				case DOUBLE_TYPE:
					return ((Double) obj).floatValue();
				case BYTE_TYPE:
					return ((Byte) obj).floatValue();
				case CHAR_TYPE:
					return (float) Character.digit((Character) obj, 10);
				case SHORT_TYPE:
					return ((Short) obj).floatValue();
				case STRING_TYPE:
					try {
						return Float.parseFloat((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				case MIX_STRING_TYPE:
					try {
						return Float.parseFloat((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				}
			}
		}
		return Float.MIN_VALUE;

	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public double toDouble() {
		if (isValue && obj != null && type == DOUBLE_TYPE) {
			return (Double) obj;
		} else {
			return Double.MIN_VALUE;
		}
	}

	/**
	 * 输出为单纯值双精度数
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public double asDouble() throws ClassCastException {
		if (isValue && type == DOUBLE_TYPE) {
			if (obj != null) {
				return (Double) obj;
			} else {
				return Double.MIN_VALUE;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 DOUBLE_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public double cvDouble() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return Double.MIN_VALUE;
			}
			switch (type) {
			case INTEGER_TYPE:
				return ((Integer) obj).doubleValue();
			case LONG_TYPE:
				return ((Long) obj).doubleValue();
			case FLOAT_TYPE:
				return ((Float) obj).doubleValue();
			case DOUBLE_TYPE:
				return (Double) obj;
			case BYTE_TYPE:
				return ((Byte) obj).doubleValue();
			case CHAR_TYPE:
				return (double) Character.digit((Character) obj, 10);
			case SHORT_TYPE:
				return ((Short) obj).doubleValue();
			case STRING_TYPE:
				try {
					return Double.parseDouble((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 STRING_TYPE 转换为 DOUBLE_TYPE 输出");
				}
			case MIX_STRING_TYPE:
				try {
					return Double.parseDouble((String) obj);
				} catch (NumberFormatException e) {
					throw new ClassCastException(
							"无法从 MIX_STRING_TYPE 转换为 DOUBLE_TYPE 输出");
				}
			default:
				throw new ClassCastException("不可转换为 DOUBLE_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public double doubleValue() {
		if (isValue) {
			if (obj != null) {
				switch (type) {
				case INTEGER_TYPE:
					return ((Integer) obj).doubleValue();
				case LONG_TYPE:
					return ((Long) obj).doubleValue();
				case FLOAT_TYPE:
					return ((Float) obj).doubleValue();
				case DOUBLE_TYPE:
					return (Double) obj;
				case BYTE_TYPE:
					return ((Byte) obj).doubleValue();
				case CHAR_TYPE:
					return (double) Character.digit((Character) obj, 10);
				case SHORT_TYPE:
					return ((Short) obj).doubleValue();
				case STRING_TYPE:
					try {
						return Double.parseDouble((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				case MIX_STRING_TYPE:
					try {
						return Double.parseDouble((String) obj);
					} catch (NumberFormatException e) {
						break;
					}
				}
			}
		}
		return Double.MIN_VALUE;

	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public boolean toBoolean() {
		if (isValue && obj != null && type == BOOLEAN_TYPE) {
			return (Boolean) obj;
		} else {
			return false;
		}
	}

	/**
	 * 输出为单纯值布尔型
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public boolean asBoolean() throws ClassCastException {
		if (isValue && type == BOOLEAN_TYPE) {
			if (obj != null) {
				return (Boolean) obj;
			} else {
				return false;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 BOOLEAN_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public boolean cvBoolean() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return false;
			}
			switch (type) {
			case BOOLEAN_TYPE:
				return (Boolean) obj;
			case INTEGER_TYPE:
				return (Integer) obj > 0;
			case LONG_TYPE:
				return (Long) obj > 0;
			case FLOAT_TYPE:
				return (Float) obj > 0;
			case DOUBLE_TYPE:
				return (Double) obj > 0;
			case BYTE_TYPE:
				return (Byte) obj > 0;
			case CHAR_TYPE:
				return Character.digit((Character) obj, 10) > 0;
			case SHORT_TYPE:
				return (Short) obj > 0;
			case STRING_TYPE:
				return "true".equals(obj.toString());
			case MIX_STRING_TYPE:
				return "true".equals(obj.toString());
			default:
				throw new ClassCastException("不可转换为 DOUBLE_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public boolean booleanValue() {
		if (isValue && obj != null) {
			switch (type) {
			case BOOLEAN_TYPE:
				return (Boolean) obj;
			case INTEGER_TYPE:
				return (Integer) obj > 0;
			case LONG_TYPE:
				return (Long) obj > 0;
			case FLOAT_TYPE:
				return (Float) obj > 0;
			case DOUBLE_TYPE:
				return (Double) obj > 0;
			case BYTE_TYPE:
				return (Byte) obj > 0;
			case CHAR_TYPE:
				return Character.digit((Character) obj, 10) > 0;
			case SHORT_TYPE:
				return (Short) obj > 0;
			case STRING_TYPE:
				return "true".equals(obj.toString());
			case MIX_STRING_TYPE:
				return "true".equals(obj.toString());
			}
		}
		return false;
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public byte[] toBytes() {
		if (isValue && obj != null && type == BYTES_TYPE) {
			return (byte[]) obj;
		} else {
			return null;
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public byte[] asBytes() throws ClassCastException {
		if (isValue && type == BYTES_TYPE) {
			if (obj != null) {
				return (byte[]) obj;
			} else {
				return null;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 BYTES_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public byte[] cvBytes() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return null;
			}
			switch (type) {
			case BYTE_TYPE:
				return new byte[] { (Byte) obj };
			case BYTES_TYPE:
				return (byte[]) obj;
			case STRING_TYPE:
				return obj.toString().getBytes();
			case MIX_STRING_TYPE:
				return obj.toString().getBytes();
			default:
				throw new ClassCastException("不可转换为 BYTES_TYPE 的类型：" + type);
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public byte[] bytesValue() {
		if (isValue && obj != null) {
			switch (type) {
			case BYTE_TYPE:
				return new byte[] { (Byte) obj };
			case BYTES_TYPE:
				return (byte[]) obj;
			case STRING_TYPE:
				return obj.toString().getBytes();
			case MIX_STRING_TYPE:
				return obj.toString().getBytes();
			}
		}
		return null;
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public byte toByte() {
		if (isValue && obj != null && type == BYTE_TYPE) {
			return (Byte) obj;
		} else {
			return Byte.MIN_VALUE;
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public byte asByte() throws ClassCastException {
		if (isValue && type == BYTE_TYPE) {
			if (obj != null) {
				return (Byte) obj;
			} else {
				return Byte.MIN_VALUE;
			}
		}
		throw new ClassCastException("当前存储值非单纯值或者非 BOOLEAN_TYPE 类型");
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public byte cvByte() throws ClassCastException {
		if (isValue) {
			if (obj == null) {
				return Byte.MIN_VALUE;
			}
			try {
				switch (type) {
				case BYTE_TYPE:
					return (Byte) obj;
				case BYTES_TYPE:
					return ((byte[]) obj)[0];
				case STRING_TYPE:
					return obj.toString().getBytes()[0];
				case MIX_STRING_TYPE:
					return obj.toString().getBytes()[0];
				default:
					throw new ClassCastException("不可转换为 BYTE_TYPE 的类型：" + type);
				}
			} catch (ArrayIndexOutOfBoundsException e) {
				return Byte.MIN_VALUE;
			}
		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public byte byteValue() {
		if (isValue && obj != null) {
			try {
				switch (type) {
				case BYTE_TYPE:
					return (Byte) obj;
				case BYTES_TYPE:
					return ((byte[]) obj)[0];
				case STRING_TYPE:
					return obj.toString().getBytes()[0];
				case MIX_STRING_TYPE:
					return obj.toString().getBytes()[0];

				}
			} catch (ArrayIndexOutOfBoundsException e) {

			}
		}
		return Byte.MIN_VALUE;
	}

	/**
	 * FIXME
	 * 
	 * @param type
	 * @return
	 */
	public Object to(int type) {
		if (isValue && type == this.type) {
			return obj;
		} else {
			return null;
		}
	}

	/**
	 * FIXME
	 * 
	 * @param type
	 * @return
	 * @throws ClassCastException
	 */
	public Object as(int type) throws ClassCastException {
		if (isValue && type == this.type) {
			return obj;
		}
		throw new ClassCastException("当前存储值非单纯值或者非 " + type + " 类型");
	}

	/**
	 * FIXME
	 * 
	 * @param type
	 * @return
	 * @throws ClassCastException
	 */
	public Object cv(int type) throws ClassCastException {
		if (isValue) {
			switch (this.type) {
			case INTEGER_TYPE:
				return cvInt();
			case LONG_TYPE:
				return cvLong();
			case FLOAT_TYPE:
				return cvFloat();
			case DOUBLE_TYPE:
				return cvDouble();
			case BOOLEAN_TYPE:
				return cvBoolean();
			case STRING_TYPE:
				return cvString();
			case MAP_TYPE:
				return cvMap();
			case COLLECTION_TYPE:
				return cvArray();
			case BYTE_TYPE:
				return cvByte();
			case CHAR_TYPE:
				return cvChar();
			case SHORT_TYPE:
				return cvShort();
			case BYTES_TYPE:
				return cvBytes();
			case OBJECT_TYPE:
				return cv();
			default:
				throw new ClassCastException("不可转换为 " + type + " 的类型："
						+ this.type);
			}

		} else {
			throw new ClassCastException("非单纯值类型");
		}
	}

	/**
	 * FIXME
	 * 
	 * @param type
	 * @return
	 */
	public Object value(int type) {
		if (isValue) {
			switch (this.type) {
			case INTEGER_TYPE:
				return intValue();
			case LONG_TYPE:
				return longValue();
			case FLOAT_TYPE:
				return floatValue();
			case DOUBLE_TYPE:
				return doubleValue();
			case BOOLEAN_TYPE:
				return booleanValue();
			case STRING_TYPE:
				return stringValue();
			case MAP_TYPE:
				return mapValue();
			case COLLECTION_TYPE:
				return arrayValue();
			case BYTE_TYPE:
				return byteValue();
			case CHAR_TYPE:
				return charValue();
			case SHORT_TYPE:
				return shortValue();
			case BYTES_TYPE:
				return bytesValue();
			case OBJECT_TYPE:
				return value();
			}
		}
		return null;
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public Object to() {
		if (isValue) {
			return obj;
		}
		return null;
	}

	/**
	 * 输出为单纯值对象
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public Object as() throws ClassCastException {
		if (!isValue) {
			throw new ClassCastException("非单纯值类型");
		}
		return obj;
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public Object cv() throws ClassCastException {
		if (!isValue) {
			throw new ClassCastException("非单纯值类型");
		}
		return obj;
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	public Object value() {
		if (isValue) {
			return obj;
		}
		return null;
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Map<String, ? extends Object> toMap() {
		if (isValue && type == MAP_TYPE) {
			try {
				return (Map<String, ? extends Object>) obj;
			} catch (ClassCastException e) {

			}
		}
		return null;
	}

	/**
	 * 输出为单纯值映射
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	@SuppressWarnings("unchecked")
	public Map<String, ? extends Object> asMap() throws ClassCastException {
		if (isValue && type == MAP_TYPE) {
			try {
				return (Map<String, ? extends Object>) obj;
			} catch (ClassCastException e) {
				throw new ClassCastException("Map类型强制转换错误");
			}
		} else {
			throw new ClassCastException("类型转换错误");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	@SuppressWarnings("unchecked")
	public Map<String, ? extends Object> cvMap() throws ClassCastException {
		if (isValue && type == MAP_TYPE) {
			try {
				return (Map<String, ? extends Object>) obj;
			} catch (ClassCastException e) {
				throw new ClassCastException("Map类型强制转换错误");
			}
		} else {
			throw new ClassCastException("类型转换错误");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Map<String, ? extends Object> mapValue() {
		if (isValue && type == MAP_TYPE) {
			try {
				return (Map<String, ? extends Object>) obj;
			} catch (ClassCastException e) {

			}
		}
		return null;
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Collection<? extends Object> toArray() {
		if (isValue && type == COLLECTION_TYPE) {
			try {
				return (Collection<? extends Object>) obj;
			} catch (ClassCastException e) {

			}
		}
		return null;
	}

	/**
	 * 输出为单纯值数组
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	@SuppressWarnings("unchecked")
	public Collection<? extends Object> asArray() throws ClassCastException {
		if (isValue && type == COLLECTION_TYPE) {
			try {
				return (Collection<? extends Object>) obj;
			} catch (ClassCastException e) {
				throw new ClassCastException("Collection类型强制转换错误");
			}
		} else {
			throw new ClassCastException("类型转换错误");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	@SuppressWarnings("unchecked")
	public Collection<? extends Object> cvArray() throws ClassCastException {
		if (isValue && type == COLLECTION_TYPE) {
			try {
				return (Collection<? extends Object>) obj;
			} catch (ClassCastException e) {
				throw new ClassCastException("Collection类型强制转换错误");
			}
		} else {
			throw new ClassCastException("类型转换错误");
		}
	}

	/**
	 * FIXME
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Collection<? extends Object> arrayValue() {
		if (isValue && type == COLLECTION_TYPE) {
			try {
				return (Collection<? extends Object>) obj;
			} catch (ClassCastException e) {

			}
		}
		return null;
	}

	/**
	 * 如果当前存储值为映射，那么输出这个映射
	 * 
	 * @return 
	 *         如果当前不存在内部映射，输出的映射，其中每个key及对应的value均不为空，但是不能保证value对应的t对象中存储的值不为空，请注意使用
	 * @throws ClassCastException
	 */
	public Map<String, TreeObject> map() throws ClassCastException {
		if (!isMap) {
			throw new ClassCastException("非Map类型T对象，无法获取子项映射");
		}
		if (attMap == null || attMap.isEmpty()) {
			return null;
		}
		// FIXME 使用浅克隆输出非线程安全的映射
		Map<String, TreeObject> m = new HashMap<String, TreeObject>();
		m.putAll(attMap);
		return m;
	}

	/**
	 * 尝试获取当前子t对象的映射键集合，如果当前不是map，那么不进行获取键
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public Set<String> mapKeys() throws ClassCastException {
		if (!isMap) {
			throw new ClassCastException("非Map类型T对象，无法获取子项键集合");
		}
		if (attMap == null || attMap.isEmpty()) {
			return null;
		}
		// FIXME 创建一个新的当前map的t对象的key集合，非联合的视图，与Map.keySet不同，对此返回的操作不影响内部
		Set<String> s = new HashSet<String>();
		s.addAll(attMap.keySet());
		return s;
	}

	/**
	 * 获取当前值集合，如果存在重复的值那么只返回其中一个，重复值是指满足hashCode和equals都相等的子t对象
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public Set<TreeObject> mapValues() throws ClassCastException {
		if (!isMap) {
			throw new ClassCastException("非Map类型T对象，无法获取子项值集合");
		}
		if (attMap == null || attMap.isEmpty()) {
			return null;
		}

		// 返回的是浅克隆，对其中t对象的操作会影响内部的子t对象
		Set<TreeObject> s = new HashSet<TreeObject>();
		s.addAll(attMap.values());
		return s;
	}

	/**
	 * 如果内部存放是数组，那么输出为数组
	 * 
	 * @return
	 * @throws ClassCastException
	 */
	public Collection<TreeObject> array() throws ClassCastException {
		if (!isArray) {
			throw new ClassCastException("类型转换错误");
		}
		if (attMap != null && !attMap.isEmpty()) {
			List<TreeObject> l = new LinkedList<TreeObject>();
			for (Integer attIndex : attIndexList) {
				TreeObject t = attMap.get(ARRAY_INDEX_TAG + attIndex);
				if (t != null) {
					l.add(t);
				}
			}
			return l;
		} else {
			return null;
		}
	}

	/**
	 * 字段 type 获取函数
	 * 
	 * @return the type : int
	 */
	public int getType() {
		return type;
	}

	/**
	 * 字段 type 设置函数 : int
	 * 
	 * @param type
	 *            the type to set
	 */
	public void setType(int type) {
		this.type = type;
	}

	/**
	 * 字段 obj 获取函数
	 * 
	 * @return the obj : Object
	 */
	public Object getObj() {
		return obj;
	}

	/**
	 * 字段 obj 设置函数 : Object
	 * 
	 * @param obj
	 *            the obj to set
	 */
	public void setObj(Object obj) {
		this.obj = obj;
	}

	/**
	 * 设置当前对象的值，使用字符串输入
	 * 
	 * @param value
	 *            字符串值
	 * @deprecated 当前方法效率太低
	 */
	public void setObj(String value) {
		if (isMap || isArray) {
			return;
		}
		isValue = true;
		if (value == null) {
			obj = null;
			return;
		}
		switch (type) {
		case INTEGER_TYPE:
			try {
				obj = Integer.parseInt(value);
			} catch (NumberFormatException e) {
				obj = Integer.MIN_VALUE;
			}
			break;
		case LONG_TYPE:
			try {
				obj = Long.parseLong(value);
			} catch (NumberFormatException e) {
				obj = Long.MIN_VALUE;
			}
			break;
		case FLOAT_TYPE:
			try {
				obj = Float.parseFloat(value);
			} catch (NumberFormatException e) {
				obj = Float.MIN_VALUE;
			}
			break;
		case DOUBLE_TYPE:
			try {
				obj = Double.parseDouble(value);
			} catch (NumberFormatException e) {
				obj = Double.MIN_VALUE;
			}
			break;
		case BOOLEAN_TYPE:
			obj = Boolean.parseBoolean(value);
			break;
		case STRING_TYPE:
			obj = value;
			break;
		case MAP_TYPE:
		case COLLECTION_TYPE:
			throw new ClassCastException(VERSION
					+ " 版本不支持解析Map或者Collection字符串转换称对应的对象");
		case BYTE_TYPE:
			try {
				obj = Base64Codec.decode(value.toCharArray())[0];
			} catch (ArrayIndexOutOfBoundsException e) {
				obj = Byte.MIN_VALUE;
			}
			break;
		case CHAR_TYPE:
			try {
				obj = value.toCharArray()[0];
			} catch (ArrayIndexOutOfBoundsException e) {
				obj = Character.MIN_VALUE;
			}
			break;
		case SHORT_TYPE:
			try {
				obj = Short.parseShort(value);
			} catch (NumberFormatException e) {
				obj = Short.MIN_VALUE;
			}
			break;
		case BYTES_TYPE:
			obj = Base64Codec.decode(value.toCharArray());
			break;
		case OBJECT_TYPE:
			throw new ClassCastException();
		case MIX_STRING_TYPE:
			obj = Base64Codec.decode(value);
			break;
		default:
			throw new ClassCastException(type + " 数据类型未知，无法从串 " + value
					+ " 转换出存储类型");
		}
	}

	/**
	 * 字段 isValue 获取函数
	 * 
	 * @return the isValue : boolean
	 */
	public boolean isValue() {
		return isValue;
	}

	/**
	 * 字段 isValue 设置函数 : boolean
	 * 
	 * @param isValue
	 *            the isValue to set
	 */
	public void setValue(boolean isValue) {
		this.isValue = isValue;
	}

	/**
	 * 字段 isArray 获取函数
	 * 
	 * @return the isArray : boolean
	 */
	public boolean isArray() {
		return isArray;
	}

	/**
	 * 字段 isArray 设置函数 : boolean
	 * 
	 * @param isArray
	 *            the isArray to set
	 */
	public void setArray(boolean isArray) {
		this.isArray = isArray;
	}

	/**
	 * 字段 isMap 获取函数
	 * 
	 * @return the isMap : boolean
	 */
	public boolean isMap() {
		return isMap;
	}

	/**
	 * 字段 isMap 设置函数 : boolean
	 * 
	 * @param isMap
	 *            the isMap to set
	 */
	public void setMap(boolean isMap) {
		this.isMap = isMap;
	}

	/**
	 * 获取T对象的json表示
	 * 
	 * @return T对象的JSON串
	 */
	public Object getJ() {
		if (attMap != null && !attMap.isEmpty()) {
			return attMap;
		}
		return obj;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		TreeObject other = (TreeObject) obj;
		if (attMap == null) {
			if (other.attMap != null)
				return false;
		} else if (!attMap.equals(other.attMap))
			return false;
		if (this.obj == null) {
			if (other.obj != null)
				return false;
		} else if (!this.obj.equals(other.obj))
			return false;
		if (type != other.type)
			return false;
		return true;
	}

	/**
	 * FIXME
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println("TObject.main():"
				+ new Long(Integer.MAX_VALUE + 1).intValue());
	}
}
